package ausgabeUndDatenverwaltung;

import einlesenUndDatenverwaltung.*;

import java.util.*;

/**
 * Ist eine Containerklasse fuer die Noten eines Studenten. Verwendet die Klasse
 * NotenlistenEintrag zur Generierung der Ausgabeliste.
 * 
 * @author (Max Bogner und Kerstin Schulze)
 * @version (14.12.2013)
 */
public class NotenListe {

	// Liste fuer alle Noten Objekt.
	private Vector<NotenlistenEintrag> notenliste = new Vector<NotenlistenEintrag>();

	/**
	 * Konstrutor zum Erzeugen von Objekten der Klasse Notenliste.
	 */
	public NotenListe() {
	}

	/**
	 * Gibt die Notenliste zurueck.
	 * 
	 * @return the notenliste
	 */
	public Vector<NotenlistenEintrag> getNotenliste() {
		return notenliste;
	}

	/**
	 * Setzt die Notenliste.
	 * 
	 * @param notenliste
	 *            die zu setzende notenliste
	 */
	public void setNotenliste(Vector notenliste) {
		this.notenliste = notenliste;
	}

	/**
	 * Methode zur Rueckgabe von Notenobjekten anhand von Index.
	 * 
	 * @author Kerstin Schulze
	 * 
	 * @param in_Nummer
	 *            (int) - Index
	 * @return (NotenlistenEintrag)- NotenlistenEintrag am Index
	 */
	public NotenlistenEintrag getNoteAtId(int in_Nummer) {
		return (NotenlistenEintrag) notenliste.elementAt(in_Nummer);
	}

	/**
	 * Gibt die Anzahl der NotenlistenEintraege in der Notenliste zurueck.
	 * 
	 * @author Kerstin Schulze
	 * @return (in) - Anzahl der Elemente in Vector als int.
	 */
	public int anzNoten() {
		return notenliste.size();
	}

	/**
	 * Fuegt der Liste ein Element hinzu.
	 * 
	 * Gibt eine Zahl als Statusmeldung zurueck.
	 * 
	 * @param buchung
	 *            Eintrag der der Liste hinzugefuegt werden soll
	 * @return Status ob der Eintrag erfolgreich eingetragen wurde
	 */
	public boolean addElement(NotenlistenEintrag nle) {
		// int Status = 1;

		try {
			notenliste.add(nle);
			return true;
		} catch (Exception e) {
			System.out.println("Error in Notenliste.addElement()"
					+ e.toString());
			// TODO: handle exception
			return false;
		}
	}

	/**
	 * Loescht das uebergebene Element aus der Liste. Gibt eine Zahl als
	 * Statusmeldung zurueck.
	 * 
	 * @param buchung
	 *            Eintrag der aus der Liste entfernt werden soll
	 * @return Status ob der Eintrag erfolgreich geloescht wurde
	 */

	public boolean removeElement(Buchung buchung) {
		try {
			notenliste.remove(buchung);
			return true;
		} catch (Exception e) {
			System.out.println("Error in Notenliste.removeElement()"
					+ e.toString());
			return false;
		}
	}

	/**
	 * Methode zum Erzeugen der Notenlisten je Uni.
	 * 
	 * @author Kerstin Schulze
	 * @param ne
	 *            (NotenListe) die fertige NotenListe
	 * @return notenlisteUni (Vector) die Notenliste nach Universitaet
	 */
	public Vector<NotenListe> createNotenlisteNachUni(NotenListe ne) {

		Vector<NotenListe> notenlisteUni = new Vector<NotenListe>();
		NotenListe bamberg = new NotenListe();
		NotenListe duisburg = new NotenListe();

		if (ne.anzNoten() > 0) {
			// Schleife, die alle Objekte der Notenliste durchlaeuft
			for (int i = 0; i < ne.anzNoten(); i++) {
				// Mache neue Notenlisteneintraege fuer Bamberg und Duisburg
				NotenlistenEintrag bam = new NotenlistenEintrag();
				NotenlistenEintrag duis = new NotenlistenEintrag();

				// aktueller Notenlisteneintrag
				NotenlistenEintrag nle = (NotenlistenEintrag) ne.getNoteAtId(i);
				// Hole Kurs und speichere diesen jeweils in dem
				// Notenlisteneintrag
				Kurs ks = (Kurs) nle.getKurs();
				bam.setKurs(ks);
				duis.setKurs(ks);

				System.out.println("Test NotenlistenachUNI bam:"
						+ bam.getKurs().getName());
				System.out.println("Test NotenlistenachUNI duis:"
						+ duis.getKurs().getName());

				// Hole Studentenliste
				StudentenListe studl = (StudentenListe) nle.getStudentenliste();

				// Neue Studentenliste Bamberg, zum Speichern der
				// Studentenobjekte
				StudentenListe studbam = new StudentenListe();
				// Neue Studentenliste Duisburg, zum Speichern der
				// Studentenobjekte
				StudentenListe studduis = new StudentenListe();

				// Ablaufen der Studentenliste- Wo studiert der Student
				// entsprechend speichern in einer separaten Studentenliste
				for (int j = 0; j < studl.anzStudenten(); j++) {
					

					// if Abfrage: studiert Student in Bamberg oder Duisburg
					// Essen, dann
					// hinzufuegen zum jeweiligen studentenliste und diese ins
					// richtige NotenlistenEintragsobjekt
					try {
						Student studlein = (Student) studl.getStudentAtIndex(j);
						if (studlein !=null){
						if (studlein.getUniversitaet().equals("Bamberg")) {
							// hinzufuegen des Studentenobjekt ins Studentenliste
							// Bamberg
							studbam.addElement(studlein);

							// einfuegen der Studentenliste in den
							// NOtenlisteneintrag bam
							bam.setStudentenliste(studbam);

							System.out
									.println("Test NotenlistenachUNI bam studl 2:"
											+ bam.getStudentenliste().toString());

						} else if (studlein.getUniversitaet().equals(
								"Duisburg-Essen")) {
							// hinzufuegen Studentenobjekt in Studentenliste
							// Duisburg
							studduis.addElement(studlein);

							// einfuegen der Studentenliste in den
							// NOtenlisteneintrag duis
							duis.setStudentenliste(studduis);

							System.out
									.println("Test NotenlistenachUNI duis studl 2:"
											+ duis.getStudentenliste().toString());
						}
						}
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				// Hinzufuegen des Notenlisteneintrags zur Notenliste nur wenn
				// Studenten vorliegen
				if (studbam.anzStudenten() > 0) {
					bamberg.addElement(bam);
				}
				if (studduis.anzStudenten() > 0) {
					duisburg.addElement(duis);
				}

				System.out.println("Test NotenlistenachUNI bamberg size:"
						+ bamberg.anzNoten());
				System.out.println("Test NotenlistenachUNI duisburg size:"
						+ duisburg.anzNoten());

			}
		} else {
			System.out
					.println("Fehler beim Kreieren der Notenlisten nach UNI. Keine Notenliste vorhanden.");

		}

		// Umformeln in notenlisteUni
		if (bamberg.anzNoten() > 0) {
			notenlisteUni.add(bamberg);
		}
		if (duisburg.anzNoten() > 0) {		
			notenlisteUni.add(duisburg);
			
		}

		return notenlisteUni;
	}



	/**
	 * Die Methode ermittelt die Anzahl der Buchungen pro Kurs und speichert sie
	 * in einer Notenliste. Hat die passende Datenstruktur NotenlistenEintrag
	 * besteht aus Kurs und der zugehoerigen Studentenliste.
	 * 
	 * @author: Daniel und Kerstin
	 * @param bl
	 *            (BuchungsListe) die Bucnungsliste
	 * @param kl
	 *            (KursListe) die Kursliste
	 * @param sl
	 *            (StudentenListe) die Studentenliste
	 */
	public void createNotenlisteFromLists(BuchungsListe bl, KursListe kl,
			StudentenListe sl) {
		// Vector fuer Buchungen je Kurs
		System.out.println("NOTENLISTE OUTPUT: ");

		// Abfrage, ob vector leer ist (also 0 Objekte enthaelt)
		if (bl.anzBuchungen() > 0) {
			int zaehler = 0;
			int aktuelleKursid = 0;
			int vergleichsOjekt = 0;
			int altes_aktObj = 0;
			// Objekt vom Typ Notenlisteneintrag: Kurs und Studentenliste
			NotenlistenEintrag kursbuch;

			// Ablaufen der Kursliste
			for (int i = 0; i < kl.anzKurse(); i++) {

				// Vergleichsobjekt aus Kursliste holen-> Kursid
				vergleichsOjekt = kl.getKursAtId(i).getKursid();
				// System.out.println ("Vergleichsobjekt:"+vergleichsOjekt);
				zaehler = 0;
				// Vector fuer Objekte, die in anzBuchungen gespeichert werden
				kursbuch = new NotenlistenEintrag();
				// Studentenliste, in der die Studenten=Buchungen gespeichert
				// werden
				StudentenListe studentenliste = new StudentenListe();

				// Schleife, die alle Objekte der Buchungsliste durchlaeuft
				for (int j = 0; j < bl.anzBuchungen(); j++) {

					Buchung buchung2 = (Buchung) bl.getBuchungAtIndex(j);
					// Kursid
					aktuelleKursid = buchung2.getKurs();

					// Kursids von Buchungsliste und Vergleichobjekt aus
					// Kursliste gleich-> zaeher hochzaehlen
					if (aktuelleKursid == vergleichsOjekt) {
						zaehler++;

						// studentenliste ist Vector fuer Studentenobjekte,
						// hinzufuegen Studentenobjekt
						int studentid = buchung2.getStudent();
						Student student = sl.getStudent(studentid);
						studentenliste.addElement(student);
						// holen der Punkte und setzen der PUnkte
						int punkte = buchung2.getPunkte();
						student.setPunkte(punkte);

						// umsetzen der Variable
						altes_aktObj = aktuelleKursid;
					}
				}
				// nur hinzufuegen wenn eine oder mehr als eine Buchung vorliegt
				if (studentenliste.anzStudenten() > 0) {
					// holen des Kurses mit der aktuellen Kursid
					Kurs kurs = kl.getKursImproved(altes_aktObj);

					// setzen der Objekte in NotenlistenEintrag
					kursbuch.setKurs(kurs);
					kursbuch.setStudentenliste(studentenliste);

					// Ausgabe
					Kurs wk = (Kurs) kursbuch.getKurs();
					String wname = wk.getName();
					StudentenListe wk2 = (StudentenListe) kursbuch
							.getStudentenliste();
					String wname2 = wk2.toString();
					System.out.println("Kurs: " + i + wname + " Zaehler: "
							+ zaehler + " Studenten: " + wname2);

					// Hinzufuegen des Objeks mit Kursbuchungen zum Gesamtvector
					notenliste.add(kursbuch);
				}
			}

			System.out.println("Groesse:" + notenliste.size());

		} else {
			// Erzeugen einer Fehlerausgabe
			System.out.println("Liste enthaelt keine Objekte");
		}
	}
	
	/**
	 * ToString Methode fuer die Elemente der Notenliste. Erstellt den
	 * Ausgabestring.
	 * 
	 * @author Kerstin Schulze
	 * 
	 * @return str (String) Zeichenkette die ausgeben wird
	 */
	public String toString() {
		String str = "------------- Notenliste nach Universitaet -----------------------------\n\n";

		if (notenliste.size() > 0) {
			// Schleife, die alle Objekte der NOtenliste durchlaeuft
			for (int i = 0; i < notenliste.size(); i++) {
				// Ausgeben des aktuellen Notenlisteneintrags
				NotenlistenEintrag nle = (NotenlistenEintrag) notenliste
						.elementAt(i);
				// hole Kurs und Kursname
				Kurs ks = (Kurs) nle.getKurs();
				String name = ks.getName();
				// hole Studentenliste
				StudentenListe studl = (StudentenListe) nle.getStudentenliste();

				// String str = new String();
				str = str + name + ": " + "\n" + studl.toString() + "\n";
			}
		} else {
			str = "Die Studentenliste konnte nicht ausgegeben werden" + "\n";

		}

		return str;
	}

}
